home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / programm.ing / ltmf_120.lzh / LTMF_EDT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-04-18  |  18.2 KB  |  712 lines
  1. /* ------------------------------------------------------------------------- */
  2. /* ----- Let 'em Fly!   V 1.2 ----------- (c) 1991-93 by Oliver Scheel ----- */
  3. /* ------------------------------------------------------------------------- */
  4. /* ----- Module: ltmf_edt.c   new form_keybd() & new objc_edit() ----------- */
  5. /* ------------------------------------------------------------------------- */
  6.  
  7. #include <stdio.h>
  8. #include <string.h>
  9. #include <macros.h>
  10. #include <ctype.h>
  11. #include <smallaes.h>
  12. #include <vdi.h>
  13. #include <tos.h>
  14. #include <portab.h>
  15.  
  16. #include "ltmf_str.h"
  17. #include "ltmf_def.h"
  18.  
  19. /* ------------------------------------------------------------------------- */
  20.  
  21. #ifdef ENGLISH
  22. #define NOSCRAP    "[1][| No clipboard available! ][ Cancel ]"
  23. #else
  24. #define NOSCRAP "[1][| Kein Klemmbrett vorhanden! ][ Abbruch ]"
  25. #endif
  26.  
  27. /* ------------------------------------------------------------------------- */
  28.  
  29. WORD ispname    _((WORD ch));
  30. WORD isfname    _((WORD ch));
  31. WORD isedctrl    _((WORD ch));
  32.  
  33. VOID obj_xywh    _((OBJECT *tree, WORD obj, GRECT *p));
  34. VOID obj_update    _((OBJECT *tree, WORD obj));
  35.  
  36. VOID rc_gtov    _((GRECT *gr, VRECT *vr));
  37.  
  38. WORD nfm_alert    _((WORD but, CHAR *string));
  39.  
  40. VOID _und_obj    _((OBJECT *tree, KBDTAB *ktab, WORD obj, WORD mode));
  41.  
  42. CHAR STDARGS ins_spcchar _((VOID));
  43. VOID STDARGS obj_clsize    _((OBJECT *tree, WORD obj, WORD *x, WORD *y, WORD *w, WORD *h));
  44.  
  45.  
  46. WORD STDARGS hist_insert    _((CHAR *str));
  47.  
  48.  
  49. MLOCAL WORD _set_text    _((OBJECT *tree, WORD obj, CHAR *txt, WORD *idx));
  50. MLOCAL WORD _hist_match    _((CHAR *str, WORD len, WORD dir));
  51. MLOCAL WORD _hist_browse _((OBJECT *tree, WORD obj, WORD *idx, CHAR *match, WORD dir));
  52. MLOCAL WORD _find_obj    _((OBJECT *tree, WORD startobj, WORD flag, WORD mode));
  53. MLOCAL WORD _get_scrap    _((CHAR *scrp));
  54.  
  55. /* ------------------------------------------------------------------------- */
  56.  
  57. EXTERN    OBJECT    *lasttree;
  58. EXTERN    WORD    magic;
  59. EXTERN    WORD    keys;
  60. EXTERN    KBDTAB    keytable[];
  61. EXTERN    WORD    ed_flag;
  62.  
  63. /* ------------------------------------------------------------------------- */
  64.  
  65. CHAR    history[MAXHIST][HISTLEN+1];    /* history buffer    */
  66.  
  67. WORD    histlow = 0;    /* history pointers    */
  68. WORD    histhi = 0;
  69. WORD    lastptr = 0;    /* browse pointer    */
  70. WORD    ed_dirty;    /* edit field 'dirty'    */
  71. CHAR    lastmatch[HISTLEN+1];
  72.  
  73. /* ------------------------------------------------------------------------- */
  74. /* ----- utilities --------------------------------------------------------- */
  75. /* ------------------------------------------------------------------------- */
  76.  
  77. MLOCAL WORD _set_text(tree, obj, txt, idx)
  78. OBJECT    *tree;
  79. WORD    obj;
  80. CHAR    *txt;
  81. WORD    *idx;
  82. {
  83.     WORD    i, j,
  84.         ok,
  85.         slen,
  86.         pvlen;
  87.     CHAR    lastvalid,
  88.         ch;
  89.     TEDINFO    *ted;
  90.  
  91.     objc_edit(tree, obj, 0, idx, ED_END);
  92.     ted = tree[obj].ob_spec.tedinfo;
  93.     for(i = 0, slen = 0; ted->te_ptmplt[i]; i++)
  94.     {
  95.         if(ted->te_ptmplt[i] == '_')
  96.             slen++;
  97.     }
  98. /*    slen = ted->te_txtlen;
  99. */    pvlen = (WORD)strlen(ted->te_pvalid);
  100.     i = j = 0;
  101.     while((i < slen) && txt[j] && (txt[j] != '\n') && (txt[j] != '\r'))
  102.     {
  103.         if(i < pvlen)
  104.             lastvalid = ted->te_pvalid[i];
  105.         ch = txt[j++];
  106.         switch(lastvalid)
  107.         {
  108.             case '9' :
  109.                 ok = isdigit(ch) ? TRUE : FALSE;
  110.                 break;
  111.             case 'A' :
  112.                 ch = toupper(ch);
  113.                 ok = (isupper(ch) || isspace(ch)) ? TRUE : FALSE;
  114.                 break;
  115.             case 'a' :
  116.                 ok = (isalpha(ch) || isspace(ch)) ? TRUE : FALSE;
  117.                 break;
  118.             case 'N' :
  119.                 ch = toupper(ch);
  120.                 ok = (isupper(ch) || isspace(ch) || isdigit(ch)) ? TRUE : FALSE;
  121.                 break;
  122.             case 'n' :
  123.                 ok = (isalpha(ch) || isspace(ch) || isdigit(ch)) ? TRUE : FALSE;
  124.                 break;
  125.             case 'F' :
  126.                 ch = toupper(ch);
  127.                 ok = (isfname(ch) || isspace(ch)) ? TRUE : FALSE;
  128.                 break;
  129.             case 'f' :
  130.                 ch = toupper(ch);
  131.                 ok = (isfname(ch) && (ch != ':') && (ch != '?') && (ch != '*')) ? TRUE : FALSE;
  132.                 break;
  133.             case 'P' :
  134.                 ch = toupper(ch);
  135.                 ok = ispname(ch) ? TRUE : FALSE;
  136.                 break;
  137.             case 'p' :
  138.                 ch = toupper(ch);
  139.                 ok = (ispname(ch) && (ch != '?') && (ch != '*')) ? TRUE : FALSE;
  140.                 break;
  141.             case 'X' :
  142.                 ok = TRUE;
  143.                 break;
  144.             default  :
  145.                 ok = FALSE;
  146.         }
  147.         if(ok)
  148.             ted->te_ptext[i++] = ch;
  149.     }
  150.     ted->te_ptext[i] = '\0';
  151.     obj_update(tree, obj);
  152.     objc_edit(tree, obj, 0, idx, ED_INIT);
  153.     return(i);
  154. }
  155.  
  156. /* ----- history functions ------------------------------------------------- */
  157.  
  158. MLOCAL WORD _hist_match(str, len, dir)
  159. CHAR    *str;
  160. WORD    len;
  161. WORD    dir;
  162. {
  163.     REG    WORD    i,
  164.             inc;
  165.  
  166.     inc = (dir == FMD_FORWARD) ? 1 : -1;
  167.     i = lastptr;
  168.     while(i != ((dir == FMD_FORWARD) ? histhi : histlow))
  169.     {
  170.         i += inc;
  171.         if(i >= MAXHIST)
  172.             i = 0;
  173.         else if(i < 0)
  174.             i = MAXHIST - 1;
  175.         if(!strncmp(history[i], str, len) /* && (history[i][0] != '\0') */ )
  176.             return(i);
  177.     }
  178.     return(-1);
  179. }
  180.  
  181. WORD STDARGS hist_insert(str)
  182. CHAR    *str;
  183. {
  184.     lastptr = histhi;
  185.     if((*str != '\0') && (_hist_match(str, HISTLEN, FMD_BACKWARD) == -1))
  186.     {
  187.         strncpy(history[histhi], str, HISTLEN);
  188.         history[histhi][HISTLEN] = '\0';
  189.         if(++histhi >= MAXHIST)
  190.             histhi = 0;
  191.         if(histhi == histlow)
  192.         {
  193.             if(++histlow >= MAXHIST)
  194.                 histlow = 0;
  195.         }
  196.         history[histhi][0] = '\0';
  197.         return(TRUE);
  198.     }
  199.     else
  200.         history[histhi][0] = '\0';
  201.     return(FALSE);
  202. }
  203.  
  204. MLOCAL WORD _hist_browse(tree, obj, idx, match, dir)
  205. OBJECT    *tree;
  206. WORD    obj;
  207. WORD    *idx;
  208. CHAR    *match;
  209. WORD    dir;
  210. {
  211.     WORD    pos;
  212.     WORD    slen;
  213.  
  214.     if(lastptr == histhi)
  215.     {
  216.         strncpy(history[histhi], tree[obj].ob_spec.tedinfo->te_ptext, HISTLEN);
  217.         history[histhi][HISTLEN] = '\0';
  218.         ed_dirty = FALSE;
  219.     }
  220.     do
  221.     {
  222.         pos = _hist_match(match, (WORD)strlen(match), dir);
  223.         if(pos != -1)
  224.         {
  225.             slen = _set_text(tree, obj, history[pos], idx);
  226.             lastptr = pos;
  227.             if(slen || (lastptr == histhi))
  228.                 return(TRUE);
  229.         }
  230.     }
  231.     while(!slen && (pos != -1));
  232.     Bconout(2, 7);
  233.     return(FALSE); 
  234. }
  235.  
  236. /* ------------------------------------------------------------------------- */
  237. /* ----- new form_button() ------------------------------------------------- */
  238. /* ------------------------------------------------------------------------- */
  239.  
  240. WORD nfm_button(tree, obj, clicks, nxtobj)
  241. OBJECT    *tree;
  242. WORD    obj;
  243. WORD    clicks;
  244. WORD    *nxtobj;
  245. {
  246.     WORD    ret;
  247.  
  248.     if(tree == lasttree)
  249.         lasttree = NULL;
  250.     ret = form_button(tree, obj, clicks, nxtobj);
  251.     if(keys && (tree[obj].ob_flags & (SELECTABLE|EXIT|TOUCHEXIT)))
  252.         _und_obj(tree, keytable, obj, 1);
  253.     return(ret);
  254. }
  255.  
  256. /* ------------------------------------------------------------------------- */
  257. /* ----- new form_keybd() -------------------------------------------------- */
  258. /* ------------------------------------------------------------------------- */
  259.  
  260. MLOCAL WORD _find_obj(tree, startobj, flag, mode)
  261. OBJECT    *tree;
  262. WORD    startobj;
  263. WORD    flag;
  264. WORD    mode;
  265. {
  266.     REG    WORD    obj;
  267.     WORD    inc,
  268.         theflag,
  269.         tflag;
  270.  
  271.     inc = (mode & FMD_BACKWARD) ? -1 : 1;
  272.     tflag = (mode & FMD_TURN) ? TRUE : FALSE;
  273.     obj = startobj;
  274.     theflag = tree[obj].ob_flags;
  275.     while(obj >= 0)
  276.     {
  277.         if((theflag & LASTOB) && !(mode & FMD_BACKWARD))
  278.         {
  279.             obj = (tflag) ? 0 : -1;
  280.             tflag = FALSE;
  281.         }
  282.         else
  283.             obj += inc;
  284.         if(obj < 0)
  285.         {
  286.             if(tflag)
  287.             {
  288.                 obj = _find_obj(tree, 0, LASTOB, FMD_FORWARD);
  289.                 tflag = FALSE;
  290.             }
  291.             else
  292.                 break;
  293.         }
  294.         theflag = tree[obj].ob_flags;
  295.         if((theflag & flag) == flag)
  296.             return(obj);
  297.     }
  298.     return(startobj);
  299. }
  300.  
  301. /* ------------------------------------------------------------------------- */
  302.  
  303. WORD nfm_keybd(tree, obj, next_obj, thechar, pnxt_obj, pchar)
  304. OBJECT    *tree;
  305. WORD    obj;
  306. WORD    next_obj;
  307. WORD    thechar;
  308. WORD    *pnxt_obj;
  309. WORD    *pchar;
  310. {
  311.     WORD    d, ks;
  312.     WORD    obtyp;
  313.     WORD    pnob_sav;
  314.     WORD    fdir,
  315.         def_obj,
  316.         def_sav;
  317.     GRECT    gr;
  318.     OBJECT    *tr;
  319.  
  320.     if(tree == lasttree)
  321.         lasttree = NULL;
  322.     obtyp = tree[ROOT].ob_type & 0xff00;
  323.     magic = ((UWORD)obtyp == MAGIC) ? TRUE : FALSE;
  324.     if((obtyp == GLOBOFF) /* || (magic && (tree[ROOT].ob_flags & EXEDIT)) */)
  325.         goto normal;
  326.     if(letemfly.conf & C_EDIT)
  327.     {
  328.         graf_mkstate(&d, &d, &d, &ks);
  329.         *pchar = thechar;
  330.         *pnxt_obj = next_obj;    /* `obj' don't work with MagicDials! */
  331.         thechar >>= 8;
  332.         if((thechar == 114) || (thechar == 28))    /* RETURN */
  333.         {
  334.             if((ks & K_CTRL) && (tree[obj].ob_flags & EDITABLE))    /* Control */
  335.             {
  336.                 hist_insert(tree[obj].ob_spec.tedinfo->te_ptext);
  337.                 *pchar = 0;
  338.                 return(1);
  339.             }
  340.             if(ks & (K_LSHIFT|K_RSHIFT))    /* Shift */
  341.             {
  342.                 *pnxt_obj = _find_obj(tree, obj, EDITABLE, FMD_FORWARD);
  343.                 if(*pnxt_obj == obj)    /* MagicDial work around */
  344.                     *pnxt_obj = next_obj;
  345.             }
  346.             if(*pnxt_obj == next_obj) /* MagicDial work around */
  347.             {
  348.                 *pnxt_obj = _find_obj(tree, ROOT, DEFAULT, FMD_FORWARD);
  349.                 if(!(*pnxt_obj))
  350.                     *pnxt_obj = _find_obj(tree, obj, EDITABLE, FMD_FORWARD);
  351.                 else
  352.                 {
  353.                     pnob_sav = *pnxt_obj;
  354.                     obj_xywh(tree, *pnxt_obj, &gr);
  355.                     objc_change(tree, *pnxt_obj, 0, gr.g_x, gr.g_y, gr.g_w, gr.g_h,
  356.                             tree[*pnxt_obj].ob_state|SELECTED, 1);
  357.                     *pnxt_obj = pnob_sav;
  358.                     *pchar = 0;
  359.                     return(0);
  360.                 }
  361.             }
  362.         }
  363.         else if((thechar == 15) && ((ks & K_ALT) || !ed_flag))    /* ALT+Tab pressed */
  364.         {
  365.             def_obj = _find_obj(tree, ROOT, EXIT|SELECTABLE|DEFAULT, FMD_FORWARD);
  366.             tr = &tree[def_obj];
  367.             def_sav = def_obj;
  368.             if(def_obj && ((tr->ob_type & 0xff) == G_BUTTON) /* && !(tr->ob_flags & TOUCHEXIT) */)
  369.             {
  370.                 obj_clsize(tree, def_obj, &gr.g_x, &gr.g_y, &gr.g_w, &gr.g_h);
  371.                 tr->ob_flags &= ~DEFAULT;
  372.                 objc_draw(tree, ROOT, MAX_DEPTH, gr.g_x, gr.g_y, gr.g_w, gr.g_h);
  373.                 lasttree = NULL;
  374.                 _und_obj(tree, keytable, def_obj, 1);
  375.                 do
  376.                 {
  377.                     fdir = (ks & (K_LSHIFT|K_RSHIFT)) ? FMD_BACKWARD : FMD_FORWARD;
  378.                     def_obj = _find_obj(tree, def_obj, EXIT|SELECTABLE, fdir|FMD_TURN);
  379.                     tr = &tree[def_obj];
  380.                 }
  381.                 while((((tr->ob_type & 0xff) != G_BUTTON) || (tr->ob_state & DISABLED) || (tr->ob_flags & HIDETREE) /* || (tr->ob_flags & TOUCHEXIT) */ ) && (def_obj != def_sav));
  382.                 tr->ob_flags |= DEFAULT;
  383.                 obj_clsize(tree, def_obj, &gr.g_x, &gr.g_y, &gr.g_w, &gr.g_h);
  384.                 objc_draw(tree, def_obj, MAX_DEPTH, gr.g_x, gr.g_y, gr.g_w, gr.g_h);
  385.                 _und_obj(tree, keytable, def_obj, 1);
  386.             }
  387.         }
  388.         else if(ks & (K_LSHIFT|K_RSHIFT))    /* Shift pressed */
  389.         {
  390.             switch(thechar)
  391.             {
  392.                 case 15 :    /* Tab */
  393.                     *pnxt_obj = _find_obj(tree, obj, EDITABLE, FMD_BACKWARD);
  394.                     break;
  395.                 case 71 :    /* Clear Home */
  396.                     *pnxt_obj = _find_obj(tree, 0, EDITABLE, FMD_BACKWARD|FMD_TURN);
  397.                     break;
  398.                 default :
  399.                     return(1);
  400.             }
  401.         }
  402.         else if(!ks)    /* normal mode */
  403.         {
  404.             switch(thechar)
  405.             {
  406.                 case 15 :    /* Tab */
  407.                     *pnxt_obj = _find_obj(tree, obj, EDITABLE, FMD_FORWARD);
  408.                     break;
  409.                 case 71 :    /* Clear Home */
  410.                     *pnxt_obj = _find_obj(tree, 0, EDITABLE, FMD_FORWARD);
  411.                     break;
  412.                 case 72 :    /* Cursor Up */
  413.                     *pnxt_obj = _find_obj(tree, obj, EDITABLE, FMD_BACKWARD|FMD_TURN);
  414.                     break;
  415.                 case 80 :    /* Cursor Down */
  416.                     *pnxt_obj = _find_obj(tree, obj, EDITABLE, FMD_FORWARD|FMD_TURN);
  417.                     break;
  418.                 default :
  419.                     return(1);
  420.             }
  421.         }
  422.         else
  423.             return(1);
  424.         *pchar = 0;
  425.         return(1);
  426.     }
  427. normal:    return(form_keybd(tree, obj, next_obj, thechar, pnxt_obj, pchar));
  428. }
  429.  
  430. /* ------------------------------------------------------------------------- */
  431. /* ----- new objc_edit ----------------------------------------------------- */
  432. /* ------------------------------------------------------------------------- */
  433.  
  434. MLOCAL WORD _get_scrap(scrp)
  435. CHAR    *scrp;
  436. {
  437.     WORD    slen;
  438.     CHAR    *s[1];
  439.  
  440.     scrp_read(scrp);
  441.     slen = (WORD)strlen(scrp);
  442.     if(!slen)
  443.     {
  444.         shel_envrn(s, "CLIPBRD=");
  445.         if(!*s)
  446.             shel_envrn(s, "SCRAPDIR=");
  447.         if(*s)
  448.         {
  449.             scrp_write(*s);
  450.             strcpy(scrp, *s);
  451.             slen = (WORD)strlen(scrp);
  452.         }
  453.     }
  454.     if(slen)
  455.     {
  456.         if(scrp[slen-1] != '\\')
  457.             strcat(scrp, "\\");
  458.         return(TRUE);
  459.     }
  460. #ifdef LIGHT
  461.     form_alert(1, NOSCRAP);
  462. #else
  463.     nfm_alert(1, NOSCRAP);
  464. #endif
  465.     return(FALSE);
  466. }
  467.  
  468. /* ------------------------------------------------------------------------- */
  469.  
  470. WORD nob_edit(tree, obj, thechar, idx, kind)
  471. OBJECT    *tree;
  472. WORD    obj;
  473. WORD    thechar;
  474. WORD    *idx;
  475. WORD    kind;
  476. {
  477.     WORD    index,
  478.         ks, d;
  479.     CHAR    *ptxt,
  480.         tchar,
  481.         ch;
  482.     WORD    ptlen;
  483.     CHAR    scrapdir[128],
  484.         delscrap[128],
  485.         scrap[128],
  486.         chbuf[64];
  487.     WORD    h, i,
  488.         slen;
  489.     WORD    obtyp;
  490.     CHAR    valsav;
  491.     OBJECT    *tr;
  492.  
  493.     if(tree == lasttree)
  494.         lasttree = NULL;
  495.     tr = &tree[obj];
  496.     index = *idx;
  497.     obtyp = tree[ROOT].ob_type & 0xff00;
  498.     magic = ((UWORD)obtyp == MAGIC) ? TRUE : FALSE;
  499.     if(!((obtyp == GLOBOFF) /* || (magic && (tree[ROOT].ob_flags & EXEDIT)) */)
  500.         && (letemfly.conf & C_EDIT) && (tr->ob_flags & EDITABLE)
  501.         /* && !(magic && (tr->ob_flags & EXEDIT)) */)
  502.     {
  503.         if(kind == ED_CHAR)
  504.         {
  505.             graf_mkstate(&d, &d, &d, &ks);
  506.             ptxt = tr->ob_spec.tedinfo->te_ptext;
  507.             ptlen = (WORD)strlen(ptxt);
  508.             tchar = thechar >> 8;
  509.             if(histhi == lastptr)
  510.             {
  511.                 strncpy(lastmatch, ptxt, HISTLEN);
  512.                 lastmatch[HISTLEN] = '\0';
  513.             }
  514.             if(ks & K_CTRL)    /* Control pressed */
  515.             {
  516.                 switch(tchar)
  517.                 {
  518.                     case 115 :    /* Cursor left */
  519.                         (*idx)--;
  520.                         while((*idx >= 0) && !(isalnum(ptxt[*idx]) || (ptxt[*idx] & 0x80)))
  521.                             (*idx)--;
  522.                         while((*idx >= 0) && (isalnum(ptxt[*idx]) || (ptxt[*idx] & 0x80)))
  523.                             (*idx)--;
  524.                         (*idx)++;
  525.                         break;
  526.                     case 116 :    /* Cursor right */
  527.                         while((*idx < ptlen) && (isalnum(ptxt[*idx]) || (ptxt[*idx] & 0x80)))
  528.                         (*idx)++;
  529.                         while((*idx < ptlen) && !(isalnum(ptxt[*idx]) || (ptxt[*idx] & 0x80)))
  530.                             (*idx)++;
  531.                         break;
  532.                     case 72 :    /* Cursor up */
  533.                         _hist_browse(tree, obj, idx, "", FMD_BACKWARD);
  534.                         return(1);
  535.                     case 80 :    /* Cursor down */
  536.                         _hist_browse(tree, obj, idx, "", FMD_FORWARD);
  537.                         return(1);
  538.                     case 47 :    /* CTRL-V */
  539.                         if(_get_scrap(scrapdir))
  540.                         {
  541.                             strcpy(scrap, scrapdir);
  542.                             strcat(scrap, "SCRAP.TXT");
  543.                             h = (WORD)Fopen(scrap, 0);
  544.                             if(h > 0)
  545.                             {
  546.                                 slen = (WORD)Fread(h, 63l, chbuf);
  547.                                 Fclose(h);
  548.                                     chbuf[slen] = '\0';
  549.                                 if(ks & (K_LSHIFT|K_RSHIFT))    /* Shift */
  550.                                     {
  551.                                     ptlen = tr->ob_spec.tedinfo->te_txtlen;    /* ??? */
  552. /*                                    ptlen = (WORD)strlen(tr->ob_spec.tedinfo->te_pvalid);
  553. */                                        for(i = 0; (*idx < ptlen) && (chbuf[i] >= 32); i++)
  554.                                             objc_edit(tree, obj, chbuf[i], idx, ED_CHAR);
  555.                                     }
  556.                                     else
  557.                                         _set_text(tree, obj, chbuf, idx);
  558.                                 }
  559.                                 ed_dirty = TRUE;
  560.                                 return(1);
  561.                             }
  562.                             break;
  563.                     case 45 :    /* CTRL-X */
  564.                     case 46 :    /* CTRL-C */
  565.                             if(_get_scrap(scrapdir))
  566.                             {
  567.                                 strcpy(scrap, scrapdir);
  568.                                 strcat(scrap, "SCRAP.TXT");
  569.                                 if(ks & (K_LSHIFT|K_RSHIFT))    /* Shift */
  570.                                 {
  571.                                     h = (WORD)Fopen(scrap, 1);
  572.                                     if(h <= 0)
  573.                                         h = (WORD)Fcreate(scrap, 0);
  574.                                     else
  575.                                     {
  576.                                         Fseek(0, h, 2);
  577.                                         Fwrite(h, 2, "\r\n");
  578.                                     }
  579.                                 }
  580.                                 else
  581.                                 {
  582.                                     strcpy(delscrap, scrapdir);
  583.                                     strcat(delscrap, "SCRAP.*");
  584.                                     while(!Fdelete(delscrap));
  585.                                     h = (WORD)Fcreate(scrap, 0);
  586.                                 }
  587.                                 if(h > 0)
  588.                                 {
  589.                                     Fwrite(h, ptlen, ptxt);
  590.                                     Fclose(h);
  591.                                 }
  592.                                 if(tchar == 45)    /* CTRL-X */
  593.                                 {
  594.                                     objc_edit(tree, obj, 0, idx, ED_END);
  595.                                     *idx = 0;
  596.                                     ptxt[*idx] = '\0';
  597.                                     obj_update(tree, obj);
  598.                                 objc_edit(tree, obj, 0, idx, ED_INIT);
  599.                                 }
  600.                                 return(1);
  601.                         }
  602.                         break;
  603.                     case 83 :    /* Delete */
  604.                         objc_edit(tree, obj, 0, idx, ED_END);
  605.                             ptxt[*idx] = '\0';
  606.                             obj_update(tree, obj);
  607.                         objc_edit(tree, obj, 0, idx, ED_INIT);
  608.                             return(1);
  609.                     default :
  610.                         goto normal;
  611.                 }
  612.             }
  613.             else if(ks & (K_LSHIFT|K_RSHIFT))    /* Shift pressed */
  614.             {
  615.                 switch(tchar)
  616.                 {
  617.                     case 75 :    /* Cursor left */
  618.                         *idx = 0;
  619.                         break;
  620.                     case 77 :    /* Cursor right */
  621.                         *idx = ptlen;
  622.                         break;
  623.                     case 72 :    /* Cursor up */
  624.                         _hist_browse(tree, obj, idx, lastmatch, FMD_BACKWARD);
  625.                             return(1);
  626.                     case 80 :    /* Cursor down */
  627.                         _hist_browse(tree, obj, idx, lastmatch, FMD_FORWARD);
  628.                             return(1);
  629.                     case 82 :    /* Insert */
  630.                         if(tr->ob_spec.tedinfo->te_pvalid[min(*idx, (WORD)strlen(tr->ob_spec.tedinfo->te_pvalid)-1)] == 'X')
  631.                             {
  632.                                 ch = ins_spcchar();
  633.                                 if(ch)
  634.                                 {
  635.                                     thechar = ch;
  636.                                     goto normal;
  637.                                 }
  638.                             }
  639.                             return(1);
  640.                     default :
  641.                         goto normal;
  642.                 }
  643.             }
  644.             else
  645.                 goto normal;
  646.             objc_edit(tree, obj, 0, &index, ED_END);
  647.             objc_edit(tree, obj, 0, idx, ED_END);
  648.             return(1);
  649.         }
  650.         else if((kind == ED_END) && ed_dirty)
  651.         {
  652.             hist_insert(tr->ob_spec.tedinfo->te_ptext);
  653.             ed_dirty = FALSE;
  654.         }
  655. normal:        lastptr = histhi;
  656.         if(kind == ED_INIT)
  657.             ed_dirty = FALSE;
  658.         else if(kind == ED_CHAR)
  659.         {
  660.             ed_dirty = TRUE;
  661.             history[histhi][0] = '\0';
  662.             index = min(index, (WORD)strlen(tr->ob_spec.tedinfo->te_pvalid) - 1);
  663.             valsav = tr->ob_spec.tedinfo->te_pvalid[index];
  664. /*            if(valsav == '\0')
  665.                 valsav = tr->ob_spec.tedinfo->te_pvalid[--index];
  666. */            ch = thechar & 0xff;
  667.             if((valsav == 'P') || (valsav == 'p') || (valsav == 'F') || (valsav == 'f'))
  668.             {
  669.                 ptxt = tr->ob_spec.tedinfo->te_ptmplt;
  670.                 while(*ptxt && (*ptxt != '_'))
  671.                     ptxt++;
  672.                 for(i = index; *ptxt && i; ptxt++)
  673.                 {
  674.                     if(*ptxt == '_')
  675.                         i--;
  676.                 }
  677.                 while(*ptxt == '_')
  678.                     ptxt++;
  679.                 if((ptxt[0] == ch) && (ptxt[1] == '_'))
  680.                     ptxt = NULL;
  681.                 switch(valsav)
  682.                 {
  683.                     case 'F' :
  684.                         if(!(isfname(ch) || isedctrl(ch)) && ptxt)
  685.                                 return(1);
  686.                             break;
  687.                     case 'f' :
  688.                         if(!((isfname(ch) && (ch != ':') && (ch != '?') && (ch != '*')) || isedctrl(ch)) && ptxt)
  689.                                 return(1);
  690.                             break;
  691.                     case 'P' :
  692.                         if(!(ispname(ch) || isedctrl(ch)) && ptxt)
  693.                                 return(1);
  694.                             break;
  695.                     case 'p' :
  696.                         if(!((ispname(ch) && (ch != '?') && (ch != '*')) || isedctrl(ch)) && ptxt)
  697.                                 return(1);
  698.                             break;
  699.                 }
  700.                 thechar &= 0xff00;
  701.                 thechar |= toupper(ch);
  702.                 if(ptxt)
  703.                     tr->ob_spec.tedinfo->te_pvalid[index] = 'X';
  704.                 objc_edit(tree, obj, thechar, idx, kind);
  705.                 tr->ob_spec.tedinfo->te_pvalid[index] = valsav;
  706.                 return(1);
  707.             }
  708.         }
  709.     }
  710.     return(objc_edit(tree, obj, thechar, idx, kind));
  711. }
  712.